home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 626-637 / disk_633 / galer / source / port.asm < prev    next >
Assembly Source File  |  1992-05-06  |  14KB  |  571 lines
  1.  
  2. *
  3. * Routinen zur Steuerung des GAL-Brenners
  4. *
  5. * assemblieren: as -n -c -d port.asm
  6. *
  7.  
  8.  
  9.  
  10.  
  11.  
  12. GAL16V8        EQU    1        ; GAL-Typ
  13. GAL20V8        EQU    2
  14.  
  15. IC1        EQU    3        ; IC-Nummer
  16. IC3        EQU    0
  17. IC4        EQU    1
  18. IC5        EQU    2
  19. IC6        EQU    0
  20. IC7        EQU    1
  21.  
  22. ON        EQU    1        ; für LED-Steuerung
  23. OFF        EQU    0
  24.  
  25. PROG        EQU    1        ; Edit-Mode für GAL
  26. VERIFY        EQU    0
  27.  
  28.  
  29.  
  30. ciaapb        EQU    $BFE101
  31. ciabpa        EQU    $BFD000
  32. ciaapbd        EQU    $BFE301
  33.  
  34.  
  35.  
  36.  
  37.     public    _InitGALer        ; GALer initialisieren
  38.     public    _WriteByte        ; Byte in Schiebereg. schreiben
  39.     public    _ReadByte        ; Byte aus Schiebereg. lesen
  40.     public    _SetGAL            ; GAL-Type festlegen
  41.     public    _VeditOn        ; Edit-Spannung aufbauen
  42.     public    _VeditOff        ; Edit-Spannung abschalten
  43.     public    _LED            ; LED ansteuern
  44.     public    _EnableVcc        ; Vcc anlegen
  45.     public    _DisableVcc        ; Vcc abschalten
  46.     public    _EnableVEdit        ; Edit-Spannung anlegen
  47.     public    _DisableVEdit        ; Edit-Spannung abschalten
  48.     public    _EnableOutput        ; Ausgangs-Treiber aktivieren
  49.     public    _DisableOutput        ; Ausgangs-Treiber deaktiviern
  50.     public    _SetRow            ; Adresse an RAG0-RAG5 anlegen
  51.     public    _SDIn            ; Lege ein Bit an SDIn-Eingang
  52.     public    _SDOut            ; Bit vom SDOut-Ausgang holen
  53.     public    _Clock            ; Clock-Impuls an SCLK-Eingang
  54.     public    _STRImpuls        ; STR-Impuls erzeugen
  55.     public    _EditMode        ; setzt Bits für Edit-Mode
  56.  
  57.  
  58.     XDEF    _GALType
  59.     XDEF    _outIC1
  60.     XDEF    _outIC3
  61.     XDEF    _outIC4
  62.     XDEF    _outIC5
  63.  
  64.  
  65.     XREF    _LVODelay
  66.  
  67.     XREF    _DOSBase
  68.     XREF    _WaitForTimer
  69.  
  70.  
  71.     cseg
  72.  
  73.  
  74. * GALer initialisieren: Datenleitung vom Par.-Port auf Ausgang, alle
  75. * Ausgänge von IC1 auf LOW (kein OutputEnable für IC3,4,5 aber Register-
  76. * Inhalt von IC3,4,5 auf LOW stellen)
  77. * Parameter: keine
  78. _InitGALer:
  79.     move.b    #$ff,ciaapbd        ; Datenleitungen auf Ausgang schalten
  80.     or.b    #%00001000,ciaapb    ; PD3=H: Adressdecoder deaktivieren!
  81.     and.b    #%00001000,ciaapb    ; alle anderen Datenleitungen auf LOW
  82.             ; ACHTUNG!!!: PD3 darf nur auf LOW-Pegel gehen
  83.             ; (Adressdecoder aktiviert werden), wenn durch PD0 und
  84.             ; PD1 das IC das angesprochen werden soll, bereits
  85.             ; selektiert ist. Ansonsten bekommt ein IC einen Takt-
  86.             ; impuls und beim nächsten Strobe liegen dann die
  87.             ; falschen Daten an.
  88.     move.w    #IC1,-(sp)
  89.     clr.w    -(sp)
  90.     bsr    _WriteByte        ; Ausgänge von IC1 auf LOW    
  91.     addq.l    #4,sp            ; Stack korrigieren
  92.     move.w    #IC3,-(sp)
  93.     clr.w    -(sp)
  94.     bsr    _WriteByte        ; Ausgänge von IC3 auf LOW    
  95.     addq.l    #4,sp            ; Stack korrigieren
  96.     move.w    #IC4,-(sp)
  97.     clr.w    -(sp)
  98.     bsr    _WriteByte        ; Ausgänge von IC4 auf LOW    
  99.     addq.l    #4,sp            ; Stack korrigieren
  100.     move.w    #IC5,-(sp)
  101.     clr.w    -(sp)
  102.     bsr    _WriteByte        ; Ausgänge von IC5 auf LOW    
  103.     addq.l    #4,sp            ; Stack korrigieren
  104.     rts
  105.  
  106.  
  107.  
  108. * SetGAL:
  109. * Setzte GAL-Type fest (GAL16V8, GAL20V8)
  110. * Aufruf: SetGAL(type);
  111. *
  112. _SetGAL:
  113.     move.w    4(sp),_GALType
  114.     rts
  115.  
  116.  
  117.  
  118. * VeditOn:
  119. * schaltet den Sperrwandler an (IC9); siehe auch VeditOff
  120. * Auruf: VeditOn();
  121. _VeditOn:
  122.     move.w    #IC1,-(sp)
  123.     or.w    #%00001,_outIC1        ; Q1 von IC1 auf HIGH => VeditOn
  124.     move.w    _outIC1,-(sp)
  125.     bsr    _WriteByte        ; IC1 setzen
  126.     addq.l    #4,sp            ; Stack korrigieren
  127.     rts
  128.  
  129. * VeditOff:
  130. * schaltet den Sperrwandler aus (IC9); siehe auch VeditOn
  131. * Auruf: VeditOff();
  132. _VeditOff:
  133.     move.w    #IC1,-(sp)
  134.     and.w    #%11111110,_outIC1    ; Q1 von IC1 auf LOW => VeditOff
  135.     move.w    _outIC1,-(sp)
  136.     bsr    _WriteByte        ; IC1 setzen
  137.     addq.l    #4,sp            ; Stack korrigieren
  138.     rts
  139.  
  140.  
  141. * EnableVEdit:
  142. * schaltet die Edit-Spannung (+16.5V) auf Pin 2 oder Pin 4 vom Textool
  143. * (abhänging vom eingestellten GAL-Typ)
  144. * Aufruf: EnableVEdit();
  145. _EnableVEdit:
  146.     move.w    #IC1,-(sp)        ; IC1 einstellen
  147.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  148.     bne.s    1$            ; nein, dann wird 20V8 angenommen!
  149.     moveq    #%00000100,d0        ; Q3 von IC1 auf HIGH
  150.     bra.s    2$
  151. 1$    moveq    #%00000010,d0        ; Q2 von IC1 auf HIGH
  152. 2$    or.w    d0,_outIC1
  153.     move.w    _outIC1,-(sp)
  154.     bsr    _WriteByte
  155.     addq.l    #4,sp
  156.     rts
  157.  
  158. * DisableVEdit:
  159. * schaltet die Edit-Spannung (+16.5V) an Pin 2 oder Pin 4 aus
  160. * (abhänging vom eingestellten GAL-Typ)
  161. * Aufruf: DisableVEdit();
  162. _DisableVEdit:
  163.     move.w    #IC1,-(sp)        ; IC1 einstellen
  164.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  165.     bne.s    1$            ; nein, dann wird 20V8 angenommen!
  166.     move.w    #%11111011,d0        ; Q3 von IC1 auf LOW
  167.     bra.s    2$
  168. 1$    move.w    #%11111101,d0        ; Q2 von IC1 auf low
  169. 2$    and.w    d0,_outIC1
  170.     move.w    _outIC1,-(sp)
  171.     bsr    _WriteByte
  172.     addq.l    #4,sp
  173.     rts
  174.  
  175.  
  176.  
  177.  
  178. * LED:
  179. * schaltet die LED aus bzw. an
  180. * Aufruf: LED(ON/OFF);
  181. _LED:
  182.     cmp.w    #ON,4(sp)
  183.     bne.s    2$
  184.     or.w    #%01000000,_outIC1
  185.     bra.s    1$
  186. 2$    and.w    #%10111111,_outIC1
  187. 1$    move.w    #IC1,-(sp)
  188.     move.w    _outIC1,-(sp)
  189.     bsr    _WriteByte        ; IC1 setzen
  190.     addq.l    #4,sp            ; Stack korrigieren
  191.     rts
  192.  
  193.  
  194.  
  195. * EnableVcc:
  196. * schaltet die Spannungsversorgung ein; siehe auch DisableVcc
  197. * bei GAL16V8: Pin22 vom Textool-Sockel
  198. * bei GAL20V8: Pin24 vom Textool-Sockel
  199. * Aufruf: EnableVcc();
  200. _EnableVcc:
  201.     move.w    #IC1,-(sp)        ; IC1 selektieren
  202.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  203.     bne.s    1$            ; nein, dann wird 20V8 angenommen!!!
  204.     moveq    #%00011000,d0        ; Q4,5 von IC1 auf HIGH=>+5V an Pin22
  205.     bra.s    2$
  206. 1$    moveq    #%00010000,d0        ; Q5 auf HIGH => +5V an Pin 24    
  207. 2$    or.w    d0,_outIC1
  208.     move.w    _outIC1,-(sp)
  209.     bsr    _WriteByte        ; IC1 setzen
  210.     addq.l    #4,sp            ; Stack korrigieren
  211.     rts
  212.  
  213. * DisableVcc:
  214. * schaltet die Spannungsversorgung aus; siehe auch EnableVcc
  215. * bei GAL16V8: Pin22 vom Textool-Sockel
  216. * bei GAL20V8: Pin24 vom Textool-Sockel
  217. * Aufruf: DisableVcc();
  218. _DisableVcc:
  219.     move.w    #IC1,-(sp)        ; IC1 selektieren
  220.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  221.     bne.s    1$            ; nein, dann wird 20V8 angenommen!!!
  222.     move.w    #%11100111,d0        ; Q4,5 von IC1 auf LOW
  223.     bra.s    2$
  224. 1$    move.w    #%11101111,d0        ; Q5 auf HIGH => +5V an Pin 24    
  225. 2$    and.w    d0,_outIC1
  226.     move.w    _outIC1,-(sp)
  227.     bsr    _WriteByte        ; IC1 setzen
  228.     addq.l    #4,sp            ; Stack korrigieren
  229.     rts
  230.  
  231.  
  232.  
  233. * EnableOutput:
  234. * OutputEnable-Eingang (OE) von IC3, IC4, IC5 auf HIGH
  235. * Aufruf: EnableOutput();
  236. _EnableOutput:
  237.     move.w    #IC1,-(sp)
  238.     or.w    #%00100000,_outIC1
  239.     move.w    _outIC1,-(sp)
  240.     bsr    _WriteByte
  241.     addq.l    #4,sp
  242.     rts
  243.  
  244. * DisableOutput:
  245. * OutputEnable-Eingang (OE) von IC3, IC4, IC5 auf LOW
  246. * Aufruf: DisableOutput();
  247. _DisableOutput:
  248.     move.w    #IC1,-(sp)
  249.     and.w    #%11011111,_outIC1
  250.     move.w    _outIC1,-(sp)
  251.     bsr    _WriteByte
  252.     addq.l    #4,sp
  253.     rts
  254.  
  255.  
  256.  
  257. * ReadByte:
  258. * lese ein Byte aus dem IC "ICx", wobei ICx=IC6 (nur ein Bit) oder IC7 ist
  259. * Aufruf: byte=ReadByte(IC);
  260. * PD3 ist bereits HIGH (muß es auch!, siehe _InitGAL und Beschreibung zu PD3)
  261. _ReadByte:
  262.     clr.w    d0
  263.     cmp.w    #IC6,4(sp)        ; IC6 angesprochen?
  264.     bne.s    IC7$            ; nein, dann IC7$
  265.     or.b    #%00000001,ciaapb    ; PD0 auf HIGH=>HIGH am Clk vom IC7
  266.                     ; PD0 auf HIGH setzen=>IC6a selektiert
  267.     move.b    ciabpa,d0
  268.     not.b    d0            ; invertieren
  269.     and.b    #%00000001,d0        ; BUSY-Bit ausmaskieren
  270.     bra.s    ready$            ; Pin22 (über IC6) ist ausgelesen
  271. IC7$
  272.  
  273.     and.b    #%11111110,ciaapb    ; PD3 ist HIGH=>Lesen möglich
  274.     nop
  275.     or.b    #%00000100,ciaapb    ; PD2 (Strobe) auf HIGH-> Daten werden
  276.     and.b    #%11111011,ciaapb    ; vom Eingangsreg. in das Schiebereg.
  277.                     ; übernommen. Dann PD2 wieder auf LOW.
  278.                     ; PD3 ist auf HIGH=>Lesen ist möglich
  279.  
  280.     moveq    #7,d2            ; Schleifenzähler
  281. l$    rol.b    #1,d0
  282.     move.b    ciabpa,d1        ; BUSY-Bit holen
  283.     and.b    #%00000001,d1        ; BUSY-Bit ausmaskieren
  284.     or.b    d1,d0            ; BUSY-Bit in D0 eintragen
  285.     and.b    #%11111110,ciaapb    ; PD0 auf LOW=>LOW am Clk-Eingang (IC7)
  286.     or.b    #%00000001,ciaapb    ; PD0 auf HIGH=>HIGH am Clk-Eingang
  287.                     ; ==> nächstes Bit steht am Ausgang
  288.     nop
  289.     nop
  290.     and.b    #%11111110,ciaapb    ; PD0 auf LOW=>IC6b ist selektiert (=>lesen möglich)
  291.     dbf    d2,l$            ; 8 Bits auslesen
  292.     not.b    d0            ; invertieren
  293. ready$    rts                ; D0=Rückgabewert (gelesenes Byte)
  294.  
  295.  
  296.  
  297. * WriteByte:
  298. * schreibt das Byte "byte" in das IC "IC", wobei IC=IC1, IC3, IC4 oder IC5
  299. * sein kann
  300. * zuerst wird das MSB übertragen!!!
  301. * Aufruf: WriteByte(byte,IC)
  302. _WriteByte:
  303.     movem.l    d0-d3,savereg        ; Register retten
  304.     move.w    4(sp),d0        ; Datenbyte nach D0
  305.     move.w    6(sp),d1        ; IC nach D1
  306.                 ; geschriebenes Byte mitprotokolieren
  307.     cmp.w    #IC1,d1
  308.     bne.s    1$
  309.     move.w    d0,_outIC1
  310.     bra.s    cont$
  311. 1$    cmp.w    #IC3,d1
  312.     bne.s    2$
  313.     move.w    d0,_outIC3
  314.     bra.s    cont$
  315. 2$    cmp.w    #IC4,d1
  316.     bne.s    3$
  317.     move.w    d0,_outIC4
  318.     bra.s    cont$
  319. 3$    move.w    d0,_outIC5
  320. cont$
  321.  
  322.     and.b    #%11111100,ciaapb    ; PD0 und PD1 setzen (IC aus-
  323.     or.b    d1,ciaapb        ; wählen)
  324.     and.b    #%11110111,ciaapb    ; Adressdecoder aktivieren
  325.  
  326.     moveq    #7,d3            ; Schleifenzähler
  327.     ror.b    #3,d0            ; MSB nach D4 (Datenleitung)
  328. loop$    move.b    d0,d2            ; Datenbyte sichern
  329.     and.b    #%00010000,d2        ; Datenbit ausmaskieren
  330.     or.b    d2,ciaapb        ; Datenbit (PD4) vom Par.-Port setzen
  331.  
  332.     or.b    #%00001000,ciaapb    ; Clock-Impuls durch PD3 geben
  333.     and.b    #%11110111,ciaapb    ; LOW-HIGH Übergang
  334.  
  335.     and.b    #%11101111,ciaapb    ; Datenbit (PD4) auf LOW
  336.  
  337.     rol.b    #1,d0            ; nächstniedrigeres Bit senden
  338.     dbf    d3,loop$
  339.  
  340.     or.b    #%00001000,ciaapb    ; Adressdecoder wieder deaktivieren!!!
  341.                     ; (sehr WICHTIG, siehe _InitGAL:)
  342.     or.b    #%00000100,ciaapb    ; PD2 (Strobe) auf HIGH-> Daten werden
  343.     and.b    #%11111011,ciaapb    ; vom Schieberegister in das Datenreg.
  344.                     ; übernommen. Dann PD2 wieder auf LOW.
  345.     movem.l    savereg,d0-d3
  346.     rts
  347.  
  348.  
  349. * SetRow:
  350. * Adresse an RAG0-RAG5 anlegen
  351. * Aufruf: SetRow(row);
  352. * row:      zu adressierende Zeile (0-63)
  353. _SetRow:
  354.  
  355.                     ; RAG5 setzen (Pin bei 16 und 20V8 gleich)
  356.     move.w    4(sp),d0        ; row holen
  357.     and.w    #$fe,_outIC5        ; Bit0(=RAG5) löschen
  358.     asr.b    #5,d0            ; Bit0 von D0=RAG5
  359.     or.w    d0,_outIC5        ; RAG5=Bit von D0=> RAG5 gesetzt
  360.  
  361.     cmp.w    #GAL16V8,_GALType    ; GAL16V8?
  362.     bne.s    GAL20V8$        ; nein, dann GAL20V8 annehmen
  363. GAL16V8$                ; RAG0 setzen
  364.     move.w    4(sp),d0        ; row holen
  365.     and.w    #$ef,_outIC3        ; Bit4(=RAG0) löschen
  366.     and.w    #1,d0            ; Bit0 von "row" ausmaskieren
  367.     asl.b    #4,d0
  368.     or.w    d0,_outIC3        ; Bit4(=RAG0) setzen
  369.                     ; RAG1-RAG4 setzen
  370.     move.w    4(sp),d0        ; row holen
  371.     and.w    #$0f,_outIC4        ; Bit4-7(=RAG1-RAG4) löschen
  372.     and.w    #%00011110,d0        ; Bit1-4 von "row" ausmaskieren
  373.     asl.w    #3,d0            ; an Bit4-7 schieben
  374.     or.w    d0,_outIC4        ; RAG1-RAG4 setzen
  375.     bra.s    write$
  376. GAL20V8$                ; RAG0 für GAL20V8 setzen
  377.      move.w    4(sp),d0        ; row holen
  378.     and.w    #%11011111,_outIC3    ; Bit5(=RAG0) löschen
  379.     and.w    #1,d0            ; Bit0 von "row" ausmaskieren
  380.     asl.b    #5,d0
  381.     or.w    d0,_outIC3        ; Bit5(=RAG0) setzen
  382.                     ; RAG4 setzen
  383.     move.w    4(sp),d0        ; row holen
  384.     and.w    #%01111111,_outIC4    ; Bit7(=RAG4) löschen
  385.     and.w    #%00010000,d0        ; Bit4 von "row" ausmaskieren
  386.     asl.w    #3,d0
  387.     or.w    d0,_outIC4        ; Bit7(=RAG4) setzen
  388.                     ; RAG1-RAG3 setzen
  389.     move.w    4(sp),d0        ; row holen
  390.     and.w    #%11100011,_outIC4    ; Bit2-4(=RAG1-RAG3) löschen
  391.     and.w    #%00001110,d0        ; Bit1-3 aus "row" ausmaskieren
  392.     asl.w    #1,d0
  393.     or.w    d0,_outIC4        ; RAG1-RAG3 setzen
  394.  
  395. write$                    ; errechnete Werte in ICs schreiben
  396.     move.w    #IC3,-(sp)
  397.     move.w    _outIC3,-(sp)
  398.     bsr    _WriteByte
  399.     addq.l    #4,sp
  400.     move.w    #IC4,-(sp)
  401.     move.w    _outIC4,-(sp)
  402.     bsr    _WriteByte
  403.     addq.l    #4,sp
  404.     move.w    #IC5,-(sp)
  405.     move.w    _outIC5,-(sp)
  406.     bsr    _WriteByte
  407.     addq.l    #4,sp
  408.     rts
  409.  
  410.  
  411.  
  412. * SDIn:
  413. * lege ein Bit an den SDIn-Eingang (Pin 11 vom Textool-Sockel)
  414. * Aufruf: SDIn(bit);    bit: 0=LOW; 1=HIGH
  415. _SDIn:
  416.     move.w    4(sp),d0        ; Bit holen
  417.     asl.b    #2,d0            ; an die richtige Stelle schieben
  418.     and.w    #%11111011,_outIC5    ; SDIn-Bit löschen
  419.     or.w    d0,_outIC5        ; Bit auf LOW oder HIGH setzen
  420.     move.w    #IC5,-(sp)
  421.     move.w    _outIC5,-(sp)
  422.     bsr    _WriteByte
  423.     addq.l    #4,sp
  424.     rts
  425.  
  426.  
  427. * SDOut:
  428. * ein Bit aus dem SDOut-Ausgang lesen
  429. * Pin 14 (GAL16V8), Pin 15 (GAL20V8) am Textool-Sockel
  430. * Aufruf: bit=SDOut();
  431. * bit: 0: SDOut-Pin ist LOW; 1: SDOut-Pin ist HIGH
  432. _SDOut:
  433.     move.w    #IC7,-(sp)        ; ein Byte aus IC7 holen
  434.     bsr    _ReadByte        ; Bit0=Pin14, Bit1=Pin15
  435.     addq.l    #2,sp
  436.     cmp.w    #GAL16V8,_GALType    ; GAL16V8 eingestellt?
  437.     bne.s    1$            ; nein, dann GAL20V8
  438.     and.w    #1,d0            ; Bit0 ausmaskieren
  439.     bra.s    2$            ; D0=Bit
  440.                     ; GAL20V8
  441. 1$    asr.w    #1,d0            ; SDOut-Bit an Bit-Pos. 0
  442.     and.w    #1,d0
  443. 2$    rts
  444.  
  445.  
  446.  
  447.  
  448. * Clock:
  449. * erzeuge Clock-Impuls (Low-High-Low-Übergang) am SCLK-Eingang (Pin 10
  450. * vom Textool-Sockel
  451. * Aufruf: Clock();
  452. _Clock:
  453.  
  454.     or.w    #%00000010,_outIC5    ; SCLK-Bit auf HIGH
  455.     move.w    #IC5,-(sp)
  456.     move.w    _outIC5,-(sp)
  457.     bsr    _WriteByte
  458.     addq.w    #4,sp
  459.     nop                ; etwas warten
  460.     nop
  461.     nop
  462.     nop
  463.     and.w    #%11111101,_outIC5    ; SCLK-Bit auf LOW
  464.     move.w    #IC5,-(sp)
  465.     move.w    _outIC5,-(sp)
  466.     bsr    _WriteByte
  467.     addq.w    #4,sp
  468.     rts
  469.  
  470.  
  471.  
  472. * STRImpuls:
  473. * setzt /STR-Eingang (Pin 13 am Textool-Socker) für 10 ms auf LOW
  474. * Aufruf: STRImpuls();
  475. _STRImpuls:
  476.     movem.l    d0-d7/a0-a6,savereg    ; Register retten
  477.  
  478.     and.w    #%11110111,_outIC5    ; STR-Pin auf LOW
  479.     move.w    #IC5,-(sp)
  480.     move.w    _outIC5,-(sp)
  481.     bsr    _WriteByte
  482.     addq.l    #4,sp
  483.  
  484.     move.l    #10000,-(sp)        ; 10000us=10ms
  485.     clr.l    -(sp)            ; 0 Sekunden warten
  486.     jsr    _WaitForTimer        ; 10 ms Low-Impuls
  487.     addq.l    #8,sp            ; Stack korrigieren
  488.  
  489.     or.w    #%00001000,_outIC5    ; STR-Pin wieder auf HIGH
  490.     move.w    #IC5,-(sp)
  491.     move.w    _outIC5,-(sp)
  492.     bsr    _WriteByte
  493.     addq.l    #4,sp
  494.  
  495.     movem.l    savereg,d0-d7/a0-a6    ; Registerinthalte zurückholen
  496.     rts
  497.  
  498.  
  499.  
  500. * Edit-Mode:
  501. * schaltet das GAL in den Edit-Mode
  502. * Aufruf: EditMode(mode);
  503. * mode:   PROG     -  GAL programmieren
  504. *      VERIFY -  GAL lesen
  505. _EditMode:
  506.     movem.l    d0-d7/a0-a6,savereg    ; Register sichern
  507.     move.w    4(sp),d0        ; "mode" holen
  508.     cmp.w    #GAL16V8,_GALType    ; GAL16V8?
  509.     bne.s    1$            ; nein, dann 1$
  510.     move.w    #IC3,-(sp)        ; IC3 setzen
  511.     move.w    #%00000000,d1
  512.     asl.b    #5,d0            ; Mode-Bit zu Bit 5 schieben
  513.     or.w    d0,d1            ; P,/V-Bit setzen
  514.     move.w    d1,-(sp)
  515.     bsr    _WriteByte
  516.     addq.l    #4,sp
  517.     move.w    #IC4,-(sp)
  518.     move.w    #%00000000,-(sp)    ; IC4 initialisieren
  519.     bsr    _WriteByte
  520.     addq.l    #4,sp
  521.     move.w    #IC5,-(sp)
  522.     move.w    #%00011000,-(sp)    ; IC5 initialisieren
  523.     bsr    _WriteByte
  524.     addq.l    #4,sp
  525.     bra.s    2$
  526. 1$                    ; GAL20V8
  527.     move.w    #IC3,-(sp)        ; IC3 setzen
  528.     move.w    #%00000000,d1
  529.     asl.b    #6,d0            ; Mode-Bit zu Bit 6 schieben
  530.     or.w    d0,d1            ; P,/V-Bit setzen
  531.     move.w    d1,-(sp)
  532.     bsr    _WriteByte
  533.     addq.l    #4,sp
  534.     move.w    #IC4,-(sp)
  535.     move.w    #%00000000,-(sp)    ; IC4 initialisieren
  536.     bsr    _WriteByte
  537.     addq.l    #4,sp
  538.     move.w    #IC5,-(sp)
  539.     move.w    #%00101000,-(sp)    ; IC5 initialisieren
  540.     bsr    _WriteByte
  541.     addq.l    #4,sp
  542. 2$
  543.     bsr    _VeditOn        ; Edit-Spannung aufbauen
  544.     bsr    _EnableOutput        ; Bits anlegen
  545.     bsr    _EnableVcc        ; Vcc anlegen
  546.     move.l    _DOSBase,a6
  547.     moveq    #20,d1            ; Prellzeit der Relais überbrücken
  548.     jsr    _LVODelay(a6)
  549.     bsr    _EnableVEdit        ; Edit-Spannung anlegen
  550.                     ; GAL befindet sich jetzt im Edit-Mode
  551.     movem.l    savereg,d0-d7/a0-a6    ; Registerinhalte zurückholen
  552.     rts
  553.  
  554.  
  555.  
  556.  
  557.  
  558.     dseg
  559.  
  560. ; Zwischenspeicher, um Register zu retten ohne den Stack zu benützen
  561. savereg:    ds.l    15        ; 8 Datenregister, 7 Adressregister
  562.  
  563. _outIC1:    dc.w    0
  564. _outIC3:    dc.w    0
  565. _outIC4:    dc.w    0
  566. _outIC5:    dc.w    0
  567. _GALType:    dc.w    0
  568.  
  569.  
  570.     END
  571.